package com.jsbs.iam.auth.controller;

import com.jsbs.iam.auth.dto.*;
import com.jsbs.iam.auth.service.UserUseService;
import com.jsbs.iam.common.core.dto.Result;
import com.jsbs.iam.common.core.utils.Json;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @BelongsProject: iam
 * @BelongsPackage: com.jsbs.iam.auth.controller
 * @Author: WangJiYuan
 * @Description: 给user服务调用的功能汇总
 * @Version: 2023-01-13  16:33
 */
@Slf4j
@RestController
@RequestMapping("/iam/auth/userUse")
public class UserUseController extends BaseController {


    @Autowired
    private UserUseService userUseService;

    /**
     * 逻辑删除组织类型和角色,用户组的关联关系
     *
     * @param deleteDto
     * @return
     */
    @PostMapping("/deleteOrgTypeRelation")
    public Result deleteOrgTypeRelation(@RequestBody OrgTypeRelationDeleteDto deleteDto) {
        log.info("Route=>UserUseController method=>deleteOrgTypeRelation 逻辑删除组织类型和角色,用户组的关联关系：{}", Json.toJsonString(deleteDto));
        try {
            if (StringUtils.isEmpty(deleteDto.getCompanyCode())) {
                log.warn("Route=>UserUseController method=>deleteOrgTypeRelation 逻辑删除组织类型和角色,用户组的关联关系，远程调用方登录人归属租户信息异常");
                return Result.failWithMsg("登录人归属租户信息异常");
            }
            if (StringUtils.isEmpty(deleteDto.getUpdatePerson())) {
                log.warn("Route=>UserUseController method=>deleteOrgTypeRelation 逻辑删除组织类型和角色,用户组的关联关系，远程调用方登录人信息异常");
                return Result.failWithMsg("登录人信息异常");
            }

            if (StringUtils.isEmpty(deleteDto.getOrgTypeCode())) {
                log.warn("Route=>UserUseController method=>deleteOrgTypeRelation 逻辑删除组织类型和角色,用户组的关联关系，没有组织类型编码,无法删除",deleteDto.getOrgTypeCode());
                return new Result(Result.FAIL, "没有组织类型编码,无法删除");
            }
            //逻辑删除组织类型和角色,用户组的关联关系
            userUseService.deleteOrgTypeRelation(deleteDto);
            return new Result<>(Result.SUCCESS, "删除成功");
        } catch (Exception e) {
            log.error("Route==>UserUseController method=>deleteOrgTypeRelation 逻辑删除组织类型和角色,用户组的关联关系，入参：{}，异常：{}", Json.toJsonString(deleteDto), e);
            return handleException(e);
        }
    }

    /**
     * 清除用户和角色,用户组的关系
     * @param deleteDto
     * @return
     */
    @PostMapping("/deleteUserRelation")
    public Result deleteUserRelation(@RequestBody UserInfoDeleteDto deleteDto) {
        log.info("Route=>UserUseController method=>deleteUserRelation 清除用户和角色,用户组的关系：{}", Json.toJsonString(deleteDto));
        try {
            if (StringUtils.isEmpty(deleteDto.getCompanyCode())) {
                log.warn("Route=>UserUseController method=>deleteUserRelation 清除用户和角色,用户组的关系，远程调用方登录人归属租户信息异常");
                return Result.failWithMsg("登录人归属租户信息异常");
            }
            if (StringUtils.isEmpty(deleteDto.getUpdatePerson())) {
                log.warn("Route=>UserUseController method=>deleteUserRelation 清除用户和角色,用户组的关系，远程调用方登录人信息异常");
                return Result.failWithMsg("登录人信息异常");
            }

            if (CollectionUtils.isEmpty(deleteDto.getUserCodes())) {
                log.info("清除用户和角色,用户组的关系,参数非法{}", deleteDto.getUserCodes());
                return new Result(Result.FAIL, "请选择数据再进行删除！");
            }
            //清除用户和角色,用户组的关系
            userUseService.deleteUserRelation(deleteDto);
            return new Result<>(Result.SUCCESS, "删除成功");
        } catch (Exception e) {
            log.error("Route==>UserUseController method=>deleteUserRelation 清除用户和角色,用户组的关系，入参：{}，异常：{}", Json.toJsonString(deleteDto), e);
            return handleException(e);
        }
    }

    /**
     * 删除应用,菜单,按钮和角色,用户组的关联关系
     * 删除应用使用
     * @param deleteDto
     * @return
     */
    @PostMapping("/deleteApplyRelation")
    public Result deleteApplyRelation(@RequestBody ApplyConfigDeleteDto deleteDto) {
        log.info("Route=>UserUseController method=>deleteApplyRelation 删除应用,菜单,按钮和角色,用户组的关联关系：{}", Json.toJsonString(deleteDto));
        try {
            if (StringUtils.isEmpty(deleteDto.getCompanyCode())) {
                log.warn("Route=>UserUseController method=>deleteApplyRelation 删除应用,菜单,按钮和角色,用户组的关联关系，远程调用方登录人归属租户信息异常");
                return Result.failWithMsg("登录人归属租户信息异常");
            }
            if (StringUtils.isEmpty(deleteDto.getUpdatePerson())) {
                log.warn("Route=>UserUseController method=>deleteApplyRelation 删除应用,菜单,按钮和角色,用户组的关联关系，远程调用方登录人信息异常");
                return Result.failWithMsg("登录人信息异常");
            }

            if (CollectionUtils.isEmpty(deleteDto.getApplyCodes())) {
                log.info("删除应用,菜单,按钮和角色,用户组的关联关系,参数非法{}", deleteDto.getApplyCodes());
                return new Result(Result.FAIL, "将要删除的应用数据为空！");
            }
            //删除应用,菜单,按钮和角色,用户组的关联关系
            userUseService.deleteApplyRelation(deleteDto);
            return new Result<>(Result.SUCCESS, "删除成功");
        } catch (Exception e) {
            log.error("Route==>UserUseController method=>deleteApplyRelation 删除应用,菜单,按钮和角色,用户组的关联关系，入参：{}，异常：{}", Json.toJsonString(deleteDto), e);
            return handleException(e);
        }
    }

    /**
     * 删除菜单,按钮和角色,用户组的关联关系
     * 删除菜单使用
     * @param deleteDto
     * @return
     */
    @PostMapping("/deleteMenuRelation")
    public Result deleteMenuRelation(@RequestBody MenuManagerDeleteDto deleteDto) {
        log.info("Route=>UserUseController method=>deleteMenuRelation 删除菜单,按钮和角色,用户组的关联关系：{}", Json.toJsonString(deleteDto));
        try {
            if (StringUtils.isEmpty(deleteDto.getCompanyCode())) {
                log.warn("Route=>UserUseController method=>deleteMenuRelation 删除菜单,按钮和角色,用户组的关联关系，远程调用方登录人归属租户信息异常");
                return Result.failWithMsg("登录人归属租户信息异常");
            }
            if (StringUtils.isEmpty(deleteDto.getUpdatePerson())) {
                log.warn("Route=>UserUseController method=>deleteMenuRelation 删除菜单,按钮和角色,用户组的关联关系，远程调用方登录人信息异常");
                return Result.failWithMsg("登录人信息异常");
            }

            //删除菜单,按钮和角色,用户组的关联关系
            userUseService.deleteMenuRelation(deleteDto);
            return new Result<>(Result.SUCCESS, "删除成功");
        } catch (Exception e) {
            log.error("Route==>UserUseController method=>deleteMenuRelation 删除菜单,按钮和角色,用户组的关联关系，入参：{}，异常：{}", Json.toJsonString(deleteDto), e);
            return handleException(e);
        }
    }

    /**
     * 删除按钮和角色,用户组的关联关系
     * 删除按钮使用
     * @param deleteDto
     * @return
     */
    @PostMapping("/deleteButtonRelation")
    public Result deleteButtonRelation(@RequestBody ButtonDeleteDto deleteDto) {
        log.info("Route=>UserUseController method=>deleteButtonRelation 删除按钮和角色,用户组的关联关系：{}", Json.toJsonString(deleteDto));
        try {
            if (StringUtils.isEmpty(deleteDto.getCompanyCode())) {
                log.warn("Route=>UserUseController method=>deleteButtonRelation 删除按钮和角色,用户组的关联关系，远程调用方登录人归属租户信息异常");
                return Result.failWithMsg("登录人归属租户信息异常");
            }
            if (StringUtils.isEmpty(deleteDto.getUpdatePerson())) {
                log.warn("Route=>UserUseController method=>deleteButtonRelation 删除按钮和角色,用户组的关联关系，远程调用方登录人信息异常");
                return Result.failWithMsg("登录人信息异常");
            }

            //删除按钮和角色,用户组的关联关系
            userUseService.deleteButtonRelation(deleteDto);
            return new Result<>(Result.SUCCESS, "删除成功");
        } catch (Exception e) {
            log.error("Route==>UserUseController method=>deleteButtonRelation 删除按钮和角色,用户组的关联关系，入参：{}，异常：{}", Json.toJsonString(deleteDto), e);
            return handleException(e);
        }
    }

    /**
     * 获取应用绑定的用户
     * @param applyConfigGetDto
     * @return
     */
    @PostMapping("/getUserDataByApply")
    public Result getUserDataByApply(@RequestBody ApplyConfigGetDto applyConfigGetDto) {
        log.info("Route=>UserUseController method=>getUserDataByApply 获取应用绑定的用户：{}", Json.toJsonString(applyConfigGetDto));
        try {
            if (StringUtils.isEmpty(applyConfigGetDto.getCompanyCode())) {
                log.warn("Route=>UserUseController method=>getUserDataByApply 获取应用绑定的用户，远程调用方登录人归属租户信息异常");
                return Result.failWithMsg("登录人归属租户信息异常");
            }
            if (StringUtils.isEmpty(applyConfigGetDto.getCreatePerson())) {
                log.warn("Route=>UserUseController method=>getUserDataByApply 获取应用绑定的用户，远程调用方登录人信息异常");
                return Result.failWithMsg("登录人信息异常");
            }
            //获取应用绑定的用户
            List<String> list = userUseService.getUserDataByApply(applyConfigGetDto);

            return Result.success("查询成功", list);
        } catch (Exception e) {
            log.error("Route==>UserUseController method=>getUserDataByApply 获取应用绑定的用户，入参：{}，异常：{}", Json.toJsonString(applyConfigGetDto), e);
            return handleException(e);
        }
    }


}
